package com.fjbdxk.beidou;

import com.fjbdxk.beidou.core.AbstractBeiDouMessage;
import com.fjbdxk.beidou.core.ByteUtils;
import com.fjbdxk.beidou.msg.BDFKIMessage;
import com.fjbdxk.beidou.msg.CCTCQMessage;
import com.fjbdxk.beidou.net.SocketBeiDouNet;
import com.fjbdxk.beidou.redis.RedisUtil;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

/**
 * 发送示例
 *
 * @author huanggy
 * @version 1.0.0
 * @date 2024/05/13
 **/
public class SendExampleTest1 {

    //分片发送参数
    public final static int part = RabbitMQExample.part * 2;//每段20字节，增加的话修改20的倍数
    private final static List<String> partInfo = new ArrayList<>();//缓存发送的段

    private static final Logger LOGGER = Logger.getLogger(SendExample.class.getName());

    public static void main(String[] args) throws InterruptedException {
        // 使用网口通信
        SocketBeiDouNet socketBeiDouNet = new SocketBeiDouNet();
        socketBeiDouNet.open();//打开网络通信
//        // 发送单次
////        sendOnce(socketBeiDouNet);
//        // 发送文件
        //String dataByRedis = getDataByRedis();
        //System.out.println(dataByRedis);
        sendFile1(socketBeiDouNet);
//        List<String> fileData = getFileData();//获取文件数据
//        for (int i = 0; i < fileData.size(); i++) {//遍历文件数据
//            partInfo.add(fileData.get(i));// 将文件数据添加到partInfo列表中
//            if (partInfo.size() == part / 20) {
//                System.out.println("分段发送的值为：" + partInfo);// 输出分段发送的值
//                sendInfo(partInfo);// 调用sendInfo方法发送partInfo列表中的数据
//            }
//        }
//        List<String> fileData = getFileData();
//        System.out.println(fileData);
        //System.out.println(100/0.01);


    }

    private static void sendFile1(SocketBeiDouNet socketBeiDouNet) throws InterruptedException {
        while (true) {
            String dataByRedis = getDataByRedis();
            // 打印分段发送的值
            System.out.println("分段发送的值为：" + dataByRedis);
            // 创建CCTCQMessage对象
            CCTCQMessage msg = new CCTCQMessage(15950114, dataByRedis);
            msg.setEncodeType(2);  // 设置编码类型
            System.out.println(msg.getMsg());  // 打印消息内容
            // 发送消息并接收响应
            BDFKIMessage res = (BDFKIMessage) socketBeiDouNet.sendMessage(msg);
            // 打印响应信息
            System.out.println(res == null ? "N" : (res.getResult() + ":" + res.getFailResult()));
            Thread.sleep(60000);  // 线程休眠55秒
        }
    }


    /**
     * 将列表中的字符串拼接后输出
     *
     * @param partInfo 字符串列表
     */
    public static void sendInfo(List<String> partInfo) {
        String ss = ""; // 创建一个空字符串
        for (int i = 0; i < partInfo.size(); i++) { // 遍历字符串列表
            ss += partInfo.get(i); // 将每个字符串拼接到ss上
        }
        System.out.println(ss); // 输出拼接后的字符串
    }

    public static String getDataByRedis() {

        int i = 0;
        String[] head = new String[]{"PLC状态", "环境温度", "风速", "功率", "转矩", "发电机转速", "叶轮转速", "风向", "桨距角", "发电量"};//csv文件的列头
        List<String> res = new ArrayList<>();//存储处理后的数据

        //String[] data = line.split(csvSplitBy);// 按照分隔符将一行数据拆分成数组
        //String[] data = getRedisByKey();
        List<String[]> data1 = getRedisByKeyNew();
        String r = "";
        for (String[] data : data1) {


            for (int j = 0; j < data.length; j++) {//遍历每个字段
                String t1 = head[j];// 获取列头
                String t2 = data[j];//获取字段值
                switch (t1) {// 根据列头进行数据处理
                    case "PLC状态":
                        t2 = validateAndSendData(t1, t2, 1.0, 0, 70, 8);
                        break;
                    case "环境温度":
                        t2 = validateAndSendData(t1, t2, 1.0, -50, 50, 8);
                        break;
                    case "风速":
                        t2 = validateAndSendData(t1, t2, 0.01, 0, 10000, 16);
                        break;
                    case "功率":
                        t2 = validateAndSendData(t1, t2, 0.01, 0, 10000, 16);
                        break;
                    case "转矩":
                        t2 = validateAndSendData(t1, t2, 0.1, 0, 10000, 16);
                        break;
                    case "发电机转速":
                        t2 = validateAndSendData(t1, t2, 1.0, 0, 2000, 16);
                        break;
                    case "叶轮转速":
                        t2 = validateAndSendData(t1, t2, 0.01, 0, 2000, 16);
                        break;
                    case "风向":
                        t2 = validateAndSendData(t1, t2, 0.1, 0, 3600, 16);
                        break;
                    case "桨距角":
                        t2 = validateAndSendData(t1, t2, 0.1, -100, 1000, 16);
                        break;
                    case "发电量":
                        t2 = validateAndSendData(t1, t2, 1.0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 32);
                        break;
                    default:
                        LOGGER.warning("Unsupported point: " + t1);// 输出不支持的列头
                        break;
                }
                System.out.println("解析之后的值为：" + t2);
                r += t2;
//                        if(j != data.length-1){
//                            r += ",";
//                        }

            }
        }
        //res.add(r);// 将处理后的数据添加到res列表中
        //}

        //System.out.println();
        i++;

        // System.out.println(res);
        return r;

    }

    private static String[] getRedisByKey() {
        String[] data = new String[10];
        //PLC状态：
        data[0] = "0";
        //温度：NacOutTmp
        data[1] = new RedisUtil().getHashValue("NacOutTmp");
        //风速：NacWdSpdFltS
        data[2] = new RedisUtil().getHashValue("NacWdSpdFltS");

        //功率：CnvW（有功功率）(float)
        data[3] = new RedisUtil().getHashValue("CnvW");

        //转矩：CnvTorq（转矩）(float)(double)
        data[4] = new RedisUtil().getHashValue("CnvTorq");

        //发电机转速：GenSpd（发电机转速）(float)(int)
        data[5] = new RedisUtil().getHashValue("GenSpd");

        //叶轮转速：RotSpd（风轮转速）(float)
        data[6] = new RedisUtil().getHashValue("RotSpd");

        //风向：NacWdDir（风向）(float)(double)
        data[7] = new RedisUtil().getHashValue("NacWdDir");

        //桨距角
        data[8] = "0";

        //发电量：WecWh（总发电量）(int)
        data[9] = new RedisUtil().getHashValue("WecWh");

        return data;

    }

    private static List<String[]> getRedisByKeyNew() {
        List<String[]> data1 = new ArrayList<>();
        for (int i = 1; i < 2; i++) {
            String incremented = String.format("%03d", i);
            String hashKey = "Wec:Jinzixian"+incremented+":TagVal";

            String[] data = new String[10];
            //PLC状态：
            data[0] = "0";
            //温度：NacOutTmp
            data[1] = new RedisUtil().getHashValue(hashKey,"NacOutTmp");
            //风速：NacWdSpdFltS
            data[2] = new RedisUtil().getHashValue(hashKey,"NacWdSpdFltS");

            //功率：CnvW（有功功率）(float)
            data[3] = new RedisUtil().getHashValue(hashKey,"CnvW");

            //转矩：CnvTorq（转矩）(float)(double)
            data[4] = new RedisUtil().getHashValue(hashKey,"CnvTorq");

            //发电机转速：GenSpd（发电机转速）(float)(int)
            data[5] = new RedisUtil().getHashValue(hashKey,"GenSpd");

            //叶轮转速：RotSpd（风轮转速）(float)
            data[6] = new RedisUtil().getHashValue(hashKey,"RotSpd");

            //风向：NacWdDir（风向）(float)(double)
            data[7] = new RedisUtil().getHashValue(hashKey,"NacWdDir");

            //桨距角
            data[8] = "0";

            //发电量：WecWh（总发电量）(int)
            data[9] = new RedisUtil().getHashValue(hashKey,"WecWh");
            data1.add(data);
            System.out.println("读取key："+hashKey);
            System.out.println("读取key的值结束数量：："+data.length);
        }


        return data1;

    }

    public static List<String> getFileData() {
        String csvFile = "D:\\工作日期\\20240514\\1.csv";//csv文件路径

        String line;
        String csvSplitBy = ",";// CSV文件中字段的分隔符

        try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(csvFile), "GBK"))) {
            int i = 0;
            String[] head = new String[]{"PLC状态", "环境温度", "风速", "功率", "转矩", "发电机转速", "叶轮转速", "风向", "桨距角", "发电量"};//csv文件的列头
            List<String> res = new ArrayList<>();//存储处理后的数据
            while ((line = br.readLine()) != null) {// 逐行读取CSV文件内容
                String[] data = line.split(csvSplitBy);// 按照分隔符将一行数据拆分成数组
                //if(i>0){
                // 在这里处理每一行的数据
                String r = "";
                for (int j = 0; j < data.length; j++) {//遍历每个字段
                    String t1 = head[j];// 获取列头
                    String t2 = data[j];//获取字段值
                    switch (t1) {// 根据列头进行数据处理
                        case "PLC状态":
                            t2 = validateAndSendData(t1, t2, 1.0, 0, 70, 8);
                            break;
                        case "环境温度":
                            t2 = validateAndSendData(t1, t2, 1.0, -50, 50, 8);
                            break;
                        case "风速":
                            t2 = validateAndSendData(t1, t2, 0.01, 0, 10000, 16);
                            break;
                        case "功率":
                            t2 = validateAndSendData(t1, t2, 0.01, 0, 10000, 16);
                            break;
                        case "转矩":
                            t2 = validateAndSendData(t1, t2, 0.1, 0, 10000, 16);
                            break;
                        case "发电机转速":
                            t2 = validateAndSendData(t1, t2, 1.0, 0, 2000, 16);
                            break;
                        case "叶轮转速":
                            t2 = validateAndSendData(t1, t2, 0.01, 0, 2000, 16);
                            break;
                        case "风向":
                            t2 = validateAndSendData(t1, t2, 0.1, 0, 3600, 16);
                            break;
                        case "桨距角":
                            t2 = validateAndSendData(t1, t2, 0.1, -100, 1000, 16);
                            break;
                        case "发电量":
                            t2 = validateAndSendData(t1, t2, 1.0, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY, 32);
                            break;
                        default:
                            LOGGER.warning("Unsupported point: " + t1);// 输出不支持的列头
                            break;
                    }
                    System.out.println("解析之后的值为：" + t2);
                    r += t2;
//                        if(j != data.length-1){
//                            r += ",";
//                        }

                }
                res.add(r);// 将处理后的数据添加到res列表中
                //}

                System.out.println();
                i++;
            }
            System.out.println(res);
            return res;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new ArrayList<>();// 返回空列表
    }

    /**
     * 验证并发送数据
     *
     * @param pointName     数据点名称
     * @param pointValueStr 数据点值字符串
     * @param coefficient   系数
     * @param lowerBound    下限
     * @param upperBound    上限
     * @param position      位置
     * @return 处理后的数据点值字符串
     */
    private static String validateAndSendData(String pointName, String pointValueStr, double coefficient, double lowerBound, double upperBound, int position) {
        if (coefficient == 1.0) {
            // 如果系数为1.0
            // 调用int-short-byte方法处理数据点值
            pointValueStr = intshortbyte(pointName, pointValueStr, (int) coefficient, lowerBound, upperBound, position);
        }
        if (coefficient == 0.1) {
            // 如果系数为0.1
            // 调用double-int-short-byte方法处理数据点值
            pointValueStr = doubleintshortbyte(pointName, pointValueStr, coefficient, lowerBound, upperBound, position);
        }
        if (coefficient == 0.01) {
            // 如果系数为0.01
            // 调用float-int-shor-tbyte方法处理数据点值
            pointValueStr = floatintshortbyte(pointName, pointValueStr, (float) coefficient, lowerBound, upperBound, position);
        }
        // 返回处理后的数据点值字符串
        return pointValueStr;
    }


    /**
     * 处理float类型数据点值
     *
     * @param pointName     数据点名称
     * @param pointValueStr 数据点值字符串
     * @param coefficient   系数
     * @param lowerBound    下限
     * @param upperBound    上限
     * @param position      位置
     * @return 处理后的数据点值字符串
     */
    private static String floatintshortbyte(String pointName, String pointValueStr, float coefficient, double lowerBound, double upperBound, int position) {
        try {
            float value = Float.parseFloat(pointValueStr) / coefficient;  // 将数据点值字符串转换为float类型并根据系数进行转换
            LOGGER.info("Range for " + pointName + ": " + lowerBound + " to " + upperBound);  // 记录数据点范围信息
            if (value < lowerBound || value > upperBound) {  // 判断转换后的值是否在范围内
                LOGGER.warning("Value for " + pointName + " out of range: " + pointValueStr);  // 记录数值超出范围的警告信息
                pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
            } else {
                int intValue = (int) value;  // 将float值转换为int
                pointValueStr = inttobyte(intValue, position);  // 调用inttobyte方法处理int值并赋给数据点值字符串
            }
        } catch (NumberFormatException e) {
            LOGGER.warning("Invalid value for " + pointName + ": " + pointValueStr);  // 记录无效数值的警告信息
            pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
        }
        return pointValueStr;  // 返回处理后的数据点值字符串
    }


    /**
     * 获取标记字符串
     *
     * @param count 标记个数
     * @return 标记字符串
     */
    private static String getTag(int count) {
        StringBuilder sb = new StringBuilder();  // 创建StringBuilder对象
        for (int i = 0; i < count; i++) {  // 循环count次
            sb.append("#");  // 在StringBuilder中添加"#"
        }
        String hashString = sb.toString();  // 将StringBuilder转换为字符串
        return hashString;  // 返回标记字符串
    }


    /**
     * 处理double类型数据点值
     *
     * @param pointName     数据点名称
     * @param pointValueStr 数据点值字符串
     * @param coefficient   系数
     * @param lowerBound    下限
     * @param upperBound    上限
     * @param position      位置
     * @return 处理后的数据点值字符串
     */
    private static String doubleintshortbyte(String pointName, String pointValueStr, double coefficient, double lowerBound, double upperBound, int position) {
        try {
            double value = Double.parseDouble(pointValueStr) / coefficient;  // 将数据点值字符串转换为double类型并根据系数进行转换
            LOGGER.info("Range for " + pointName + ": " + lowerBound + " to " + upperBound);  // 记录数据点范围信息
            if (value < lowerBound || value > upperBound) {  // 判断转换后的值是否在范围内
                LOGGER.warning("Value for " + pointName + " out of range: " + pointValueStr);  // 记录数值超出范围的警告信息
                pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
            } else {
                //double doubleValue = 1234.5678;
                int intValue = (int) value;  // 将double值转换为int
                pointValueStr = inttobyte(intValue, position);  // 调用inttobyte方法处理int值并赋给数据点值字符串
            }
        } catch (NumberFormatException e) {
            LOGGER.warning("Invalid value for " + pointName + ": " + pointValueStr);  // 记录无效数值的警告信息
            pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
        }
        return pointValueStr;  // 返回处理后的数据点值字符串
    }


    /**
     * 处理int类型数据点值
     *
     * @param pointName     数据点名称
     * @param pointValueStr 数据点值字符串
     * @param coefficient   系数
     * @param lowerBound    下限
     * @param upperBound    上限
     * @param position      位置
     * @return 处理后的数据点值字符串
     */
    private static String intshortbyte(String pointName, String pointValueStr, int coefficient, double lowerBound, double upperBound, int position) {
        try {
            int value = Integer.parseInt(pointValueStr) / coefficient;  // 将数据点值字符串转换为int类型并根据系数进行转换
            LOGGER.info("Range for " + pointName + ": " + lowerBound + " to " + upperBound);  // 记录数据点范围信息
            if (value < lowerBound || value > upperBound) {  // 判断转换后的值是否在范围内
                LOGGER.warning("Value for " + pointName + " out of range: " + pointValueStr);  // 记录数值超出范围的警告信息
                pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
            } else {
                pointValueStr = inttobyte(value, position);  // 调用inttobyte方法处理int值并赋给数据点值字符串
            }
        } catch (NumberFormatException e) {
            LOGGER.warning("Invalid value for " + pointName + ": " + pointValueStr);  // 记录无效数值的警告信息
            pointValueStr = getTag(position);  // 获取标记值并赋给数据点值字符串
        }
        return pointValueStr;  // 返回处理后的数据点值字符串
    }


    //    public static void main(String[] args) {
//        float floatValue = 123.45f;
//        int intValue = (int) floatValue;
//        short shortValue = (short) intValue;
//        System.out.println(Integer.toBinaryString(shortValue));
//        //System.out.println(toBinaryString(shortValue));
//        System.out.println("Float value " + floatValue + " converted to int: " + intValue);
//        System.out.println(inttobyte(123));
//    }
    public static String toBinaryString(short value) {
        StringBuilder sb = new StringBuilder(Short.SIZE); // Short.SIZE is 16,创建一个StringBuilder对象sb，容量为Short.SIZE，即16
        for (int i = Short.SIZE - 1; i >= 0; i--) {// 从15开始循环到0
            sb.append((value & (1 << i)) != 0 ? '1' : '0');// 将value与(1左移i位)进行按位与操作，结果不为0则追加'1'，否则追加'0'到sb中
        }
        return sb.toString();// 返回sb转换为字符串后的结果
    }
//    public static String inttobyte(int number){
//        int decimalNumber = 35;
//
//        String binaryString = Integer.toBinaryString(decimalNumber);
//
//        // Ensure the binary string is exactly 8 bits (1 byte) long
//        String paddedBinaryString = String.format("%8s", binaryString).replace(' ', '0');
//
//        // Print the padded binary representation
//        System.out.println("Padded binary representation of " + decimalNumber + " is: " + paddedBinaryString);
//        return paddedBinaryString;
//    }

    /**
     * 将整数转换为字节串
     *
     * @param number   要转换的整数
     * @param position 二进制串的长度
     * @return 转换后的二进制字符串
     */
    public static String inttobyte(int number, int position) {
        //float->int-short-byte
        // 将整数转换为短整数
        int decimalNumber = number;
        short shortValue = (short) decimalNumber;
        // 将短整数转换为二进制字符串
        String binaryString = Integer.toBinaryString(shortValue);

        // Ensure the binary string is exactly 8 bits (1 byte) long
        // 确保二进制字符串的长度为position
        String paddedBinaryString = String.format("%" + position + "s", binaryString).replace(' ', '0');

        // Print the padded binary representation
        // 打印填充后的二进制表示
        System.out.println("Padded binary representation of " + decimalNumber + " is: " + paddedBinaryString);
        return paddedBinaryString;// 返回填充后的二进制字符串
    }

    public static String toData2(int number) {
        //short number = 10000;

        // 使用 ByteBuffer 将整数转换为字节
        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);// 创建一个ByteBuffer对象，分配Integer.BYTES（4）个字节的空间
        buffer.putInt(number);// 将整数写入到ByteBuffer中
        byte[] bytes = buffer.array();// 获取ByteBuffer中的字节数组

//            String str = "10000";
//
//            // 将字符串转换为字节数组（使用默认的字符集）
//            byte[] bytes = str.getBytes();

        // 输出转换后的字节数组
        System.out.println("字节数组: " + bytesToHex(bytes)); // 输出16进制字符串表示的字节数组
        return bytesToHex(bytes);// 返回16进制字符串表示的字节数组
    }

    //short转为byte
    public static String toData(short number) {
        //short number = 10000;

        // 使用 ByteBuffer 将整数转换为字节
        ByteBuffer buffer = ByteBuffer.allocate(Short.BYTES);
        buffer.putShort(number);
        byte[] bytes = buffer.array();

//            String str = "10000";
//
//            // 将字符串转换为字节数组（使用默认的字符集）
//            byte[] bytes = str.getBytes();

        // 输出转换后的字节数组
        System.out.println("字节数组: " + bytesToHex(bytes)); // 输出16进制字符串表示的字节数组
        return bytesToHex(bytes);
    }

    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param bytes 要转换的字节数组
     * @return 转换后的十六进制字符串
     */
    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder(2 * bytes.length); // 创建一个StringBuilder对象用于存储转换后的十六进制字符串，初始容量为字节数组长度的两倍
        for (byte b : bytes) { // 遍历字节数组中的每个字节
            String hex = String.format("%02x", b); // 将每个字节格式化为两位十六进制字符串
            hexString.append(hex); // 将格式化后的十六进制字符串追加到StringBuilder对象中
        }
        return hexString.toString(); // 将StringBuilder对象转换为String并返回
    }


    //byte转为short
    public static String toData1(short number) {
        // 十六进制字符串表示的字节数据
        String hexString = "0032";

        // 解析十六进制字符串为字节数组
        byte[] bytes = hexStringToByteArray(hexString);

        // 将字节数组转换为 short 类型
        short value = bytesToShort(bytes);

        // 输出转换后的 short 值
        System.out.println("转换后的 short 值: " + value);
        return "";
    }
    // 辅助方法：将十六进制字符串转换为字节数组

    /**
     * 将十六进制字符串转换为字节数组
     *
     * @param hexString 要转换的十六进制字符串
     * @return 转换后的字节数组
     */
    private static byte[] hexStringToByteArray(String hexString) {
        int len = hexString.length(); // 获取十六进制字符串的长度
        byte[] data = new byte[len / 2]; // 创建一个字节数组，长度为十六进制字符串长度的一半
        for (int i = 0; i < len; i += 2) { // 遍历十六进制字符串中的每两个字符
            data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4) // 将两个十六进制字符转换为一个字节并存储到字节数组中
                    + Character.digit(hexString.charAt(i + 1), 16));
        }
        return data; // 返回转换后的字节数组
    }


    // 辅助方法：将字节数组转换为 short 类型

    /**
     * 将两个字节的字节数组转换为short类型
     *
     * @param bytes 两个字节的字节数组
     * @return 转换后的short类型数据
     */
    private static short bytesToShort(byte[] bytes) {
        return (short) (((bytes[0] & 0xFF) << 8) | (bytes[1] & 0xFF));
    }

    public static void sendOnce(SocketBeiDouNet socketBeiDouNet) {
        CCTCQMessage cctcqMessage = new CCTCQMessage(15950041, "41424344");
        cctcqMessage.setEncodeType(2);
        System.out.println(cctcqMessage.getMsg());
        AbstractBeiDouMessage abstractBeiDouMessage = socketBeiDouNet.sendMessage(cctcqMessage);
        if (abstractBeiDouMessage instanceof BDFKIMessage) {
            BDFKIMessage bdfkiMessage = (BDFKIMessage) abstractBeiDouMessage;
            if ("Y".equals(bdfkiMessage.getResult())) {
                System.out.println("发射成功");
            } else {
                System.out.println("发射失败，原因：" + bdfkiMessage.getFailResult());
            }
        } else {
            System.out.println("unknown error message");
        }
    }

    /**
     * 发送文件数据到Socket贝斗网
     *
     * @param socketBeiDouNet Socket贝斗网对象
     * @throws InterruptedException 中断异常
     */
    public static void sendFile(SocketBeiDouNet socketBeiDouNet) throws InterruptedException {
        // 获取文件数据
        List<String> fileData = getFileData();
        // 遍历文件数据列表
        for (int i = 0; i < fileData.size(); i++) {
            // 打印分段发送的值
            System.out.println("分段发送的值为：" + fileData.get(i));
            // 创建CCTCQMessage对象
            CCTCQMessage msg = new CCTCQMessage(15950114, fileData.get(i));
            msg.setEncodeType(2);  // 设置编码类型
            System.out.println(msg.getMsg());  // 打印消息内容
            // 发送消息并接收响应
            BDFKIMessage res = (BDFKIMessage) socketBeiDouNet.sendMessage(msg);
            // 打印响应信息
            System.out.println(res == null ? "N" : (res.getResult() + ":" + res.getFailResult()));
            Thread.sleep(60000);  // 线程休眠55秒
        }
    }


    public static void parse() {


        byte[] bytes = ByteUtils.hexStr2bytes("325F303030315F345F453442383830453442413843453442383839453539423942453442413934453538354144453442383833453538354142453442393944453538443831453442383830453442413843453442383839453539423942453442413934453538354144453442383833453538354142453442393944453538443831453442383830453442413843453442383839453539423942453442413934453538354144453442383833453538354142453442393944453538443831");
        System.out.println(new String(bytes));
        byte[] bytes1 = ByteUtils.hexStr2bytes("325F303030315F315F5B42403137656434306530");
        System.out.println(new String(bytes1));
        byte[] bytes2 = ByteUtils.hexStr2bytes("325F303030315F325F5B42403530363735363930");
        System.out.println(new String(bytes2));
        byte[] bytes3 = ByteUtils.hexStr2bytes("325F303030315F335F5B42403331623764656130");
        System.out.println(new String(bytes3));
        byte[] bytes4 = ByteUtils.hexStr2bytes("325F303030315F345F5B42403361633432393136");
        System.out.println(new String(bytes4));
        byte[] bytes5 = ByteUtils.hexStr2bytes("325F303030315F355F5B42403437643338346565");
        System.out.println(new String(bytes5));
    }
}
